const UserModel = require('../models/user.model');
const logger = require('../utils/logger');
const Response = require('../utils/response');

class UserController {
  // 创建用户
  async createUser(req, res) {
    try {
      const { username, email, password, role } = req.body;
      
      // 验证必填字段
      if (!username || !email || !password) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '用户名、邮箱和密码为必填项'
          })
        );
      }

      // 验证字段格式
      if (typeof username !== 'string' || username.trim().length === 0) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '无效的用户名'
          })
        );
      }
      if (typeof email !== 'string' || !email.includes('@')) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '无效的邮箱地址'
          })
        );
      }
      if (typeof password !== 'string' || password.length < 6) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '密码长度至少为6位'
          })
        );
      }

      // 创建用户数据对象
      const userData = {
        username: username.trim(),
        email: email.trim(),
        password: password,
        role: role || 'user'  // 设置默认角色
      };

      try {
        const userId = await UserModel.create(userData);
        const newUser = await UserModel.findById(userId);
        
        res.status(201).json(
          Response.success({
            code: 201,
            message: '用户创建成功',
            data: newUser
          })
        );
      } catch (dbError) {
        // 处理特定的业务错误
        if (dbError.message.includes('用户名已存在') || 
            dbError.message.includes('邮箱已存在')) {
          return res.status(400).json(
            Response.error({
              code: 400,
              message: dbError.message
            })
          );
        }

        // 记录详细错误信息
        logger.error('创建用户失败:', {
          error: dbError.message,
          stack: dbError.stack,
          userData: { ...userData, password: '***' } // 隐藏密码
        });

        // 返回用户友好的错误信息
        res.status(500).json(
          Response.error({
            message: '创建用户失败，请稍后重试',
            data: {
              error: dbError.message
            }
          })
        );
      }
    } catch (error) {
      // 处理其他未预期的错误
      logger.error('创建用户过程发生未知错误:', {
        error: error.message,
        stack: error.stack
      });

      res.status(500).json(
        Response.error({
          message: '服务器内部错误，请稍后重试'
        })
      );
    }
  }

  // 获取所有用户
  async getAllUsers(req, res) {
    try {
      const users = await UserModel.findAll();
      res.json(
        Response.success({
          data: users
        })
      );
    } catch (error) {
      logger.error('获取用户列表失败:', error);
      res.status(500).json(
        Response.error({
          message: '获取用户列表失败'
        })
      );
    }
  }

  // 获取单个用户
  async getUserById(req, res) {
    try {
      const user = await UserModel.findById(req.params.id);
      if (!user) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '用户不存在'
          })
        );
      }
      res.json(
        Response.success({
          data: user
        })
      );
    } catch (error) {
      logger.error('获取用户详情失败:', error);
      res.status(500).json(
        Response.error({
          message: '获取用户详情失败'
        })
      );
    }
  }

  // 更新用户
  async updateUser(req, res) {
    try {
      const { username, email, password, role } = req.body;
      const userId = req.params.id;

      // 检查用户是否存在
      const user = await UserModel.findById(userId);
      if (!user) {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: '用户不存在'
          })
        );
      }

      // 如果更新用户名，检查是否与其他用户重复
      if (username && username !== user.username) {
        const existingUsername = await UserModel.findByUsername(username);
        if (existingUsername) {
          return res.status(400).json(
            Response.error({
              code: 400,
              message: '用户名已存在'
            })
          );
        }
      }

      // 如果更新邮箱，检查是否与其他用户重复
      if (email && email !== user.email) {
        const existingEmail = await UserModel.findByEmail(email);
        if (existingEmail) {
          return res.status(400).json(
            Response.error({
              code: 400,
              message: '邮箱已存在'
            })
          );
        }
      }

      const success = await UserModel.update(userId, { username, email, password, role });
      if (success) {
        const updatedUser = await UserModel.findById(userId);
        res.json(
          Response.success({
            message: '用户更新成功',
            data: updatedUser
          })
        );
      } else {
        res.status(400).json(
          Response.error({
            message: '用户更新失败'
          })
        );
      }
    } catch (error) {
      logger.error('更新用户失败:', error);
      res.status(500).json(
        Response.error({
          message: '更新用户失败'
        })
      );
    }
  }

  // 删除用户
  async deleteUser(req, res) {
    try {
      const userId = req.params.id;
      
      // 检查用户ID是否有效
      if (!userId || isNaN(userId)) {
        return res.status(400).json(
          Response.error({
            code: 400,
            message: '无效的用户ID'
          })
        );
      }

      await UserModel.softDelete(userId);
      
      res.json(
        Response.success({
          message: '用户删除成功'
        })
      );
    } catch (error) {
      // 处理特定的业务错误
      if (error.message === '用户不存在或已删除') {
        return res.status(404).json(
          Response.error({
            code: 404,
            message: error.message
          })
        );
      }

      // 记录详细错误信息
      logger.error('删除用户失败:', {
        error: error.message,
        stack: error.stack,
        userId: req.params.id
      });

      // 返回用户友好的错误信息
      res.status(500).json(
        Response.error({
          message: '删除用户失败，请稍后重试'
        })
      );
    }
  }

  // 恢复已删除的用户
  async restoreUser(req, res) {
    try {
      const success = await UserModel.restore(req.params.id);
      if (success) {
        res.json(
          Response.success({
            message: '用户恢复成功'
          })
        );
      } else {
        res.status(404).json(
          Response.error({
            code: 404,
            message: '用户不存在或未删除'
          })
        );
      }
    } catch (error) {
      logger.error('恢复用户失败:', error);
      res.status(500).json(
        Response.error({
          message: '恢复用户失败'
        })
      );
    }
  }
}

module.exports = new UserController(); 